<template></template>

<script setup>
import * as Cesium from "cesium";
import GridCell from "./GridCell_v2.3.js";
import { ref } from "vue";

// 添加 uavData 的定义
const uavData = ref({
  trajectories: {}, // 实际轨迹数据
  planTrajectories: {}, // 计划轨迹数据
  indices: {}, // 当前轨迹索引
  lastPositions: {}, // 最后位置记录
});

async function init(Viewer) {
  const uavConfig = [
    {
      name: "无人机26号",
      file: "rotate90.json",
      planFile: "rotate90.json",
      snCode: "UAV-0261",
      img: "/img/uav_2_1.svg",
      color: 1,
    },
    {
      name: "无人机27号",
      file: "25FH5603-XHJ-01.json",
      planFile: "25FH5603-XHJ-01.json",
      snCode: "UAV-0262",
      img: "/img/uav_2_1.svg",
      color: 2,
    },
    {
      name: "无人机28号",
      file: "AD134123.json",
      planFile: "AD134123.json",
      snCode: "UAV-0263",
      img: "/img/uav_2_1.svg",
      color: 3,
    },
    {
      name: "无人机28号",
      file: "DJI102Z11058.json",
      planFile: "DJI102Z11058.json",
      snCode: "UAV-0263",
      img: "/img/uav_2_1.svg",
      color: 3,
    },
  ];

  // 直接传递数组，函数内部会处理所有配置
  const result = await loadUavTrajectoryData(uavConfig);

  // 飞入第一个点result[0].planData[0]
  console.log(result[0].planData, "result");

  // 检查是否有数据并飞行到第一个点
  if (
    result &&
    result.length > 0 &&
    result[0].planData &&
    result[0].planData.length > 0
  ) {
    const firstPoint = result[0].planData[0];
    console.log("准备飞行到第一个点:", firstPoint);

    // 使用 Cesium 相机飞行到第一个点
    // 假设坐标格式为 [经度, 纬度, 高度]
    Viewer.camera.flyTo({
      destination: Cesium.Cartesian3.fromDegrees(
        firstPoint[0], // 经度
        firstPoint[1], // 纬度
        firstPoint[2] + 500 // 高度 + 500米的偏移以获得更好的视角
      ),
      duration: 3, // 飞行时间3秒
      complete: () => {
        console.log("已飞行到第一个无人机的计划轨迹起始点");
      },
    });
  } else {
    console.warn("没有找到有效的轨迹数据");
  }

  const gridCell = new GridCell(Viewer, [0, 0, 0], 15);
  const gridCell2 = new GridCell(Viewer, [0, 0, 0], 15);

  loadPoint(Viewer, result[2].planData);
  // loadPoint(Viewer,result[2].planData)
  loadPoint(Viewer, result[1].planData);
  // loadPoint(Viewer,result[3].planData)

  // 遍历result[0].planData, result[1].planData数组，返回三个数组，第一个是完整的result[0].planData，第二个是result[0].planData和result[1].planData交集，第三个是非共有中result[1].planData的部分
  // const [firstArray, intersection, secondUnique] = compareTrajectories(
  //   result[1].planData,
  //   result[0].planData
  // );
  // console.log("第一条轨迹数组长度:", firstArray.length);
  // console.log("两条轨迹的交集长度:", intersection.length);
  // console.log("第二条轨迹独有部分长度:", secondUnique.length);

  // gridCell.loadGridDataBatch(
  //   [firstArray, intersection, secondUnique],
  //   ["Green", "White", "Red"]
  // );

  // gridCell.changeColor(result[0].planData[12], 'White')
  // gridCell.loadGridDataJson(result[0].planData, 'Green')
  // gridCell.loadGridDataJson(result[2].planData, 'Green')
  // gridCell2.loadGridDataJson(result[1].planData, 'Green')

  let index = 0;
  setInterval(() => {
    if (index < result[2].planData.length) {
      // gridCell.changeColor(result[2].planData[index], "Red");
      // gridCell.drawSingleBox(result[1].planData[index], 'Green')
      // if (index === 21) {
      //   gridCell.changeOrDraw(result[2].planData[index], ['White', 'Red'])
      // } else {
      //   gridCell.changeOrDraw(result[2].planData[index], ['White', 'White'])
      // }
      gridCell.drawSingleBox(result[2].planData[index], "Red");

      index++;
    } else {
      // index = 0
      return;
    }
  }, 100);

  // let index1 = 0
  // setInterval(() => {
  //   if (index1 < result[2].planData.length) {
  //     gridCell.changeColor(result[2].planData[index1], 'White')
  //     index1++
  //   } else {
  //     index1 = 0
  //   }
  // }, 1000);
}

/**
 * 比较两个轨迹数组，找出它们的交集和独有部分
 * @param {Array} array1 - 第一个轨迹数组
 * @param {Array} array2 - 第二个轨迹数组
 * @returns {Array} - 返回三个数组：[完整的array1, array1和array2的交集, array2中独有的部分]
 */
function compareTrajectories(array1, array2) {
  // 用于存储交集的数组
  const intersection = [];
  // 用于存储array2中独有部分的数组
  const secondUnique = [];

  // 创建一个Map来存储array1中的点，用于快速查找
  // 使用点的坐标字符串作为键
  const array1Map = new Map();

  // 将array1中的所有点添加到Map中
  array1.forEach((point) => {
    const key = point.join(","); // 使用点坐标拼接成字符串作为键
    array1Map.set(key, point);
  });

  // 遍历array2，检查每个点是否在array1中存在
  array2.forEach((point) => {
    const key = point.join(",");

    if (array1Map.has(key)) {
      // 如果点在array1中存在，则添加到交集中
      intersection.push(point);
    } else {
      // 如果点在array1中不存在，则添加到array2独有部分中
      secondUnique.push(point);
    }
  });

  return [array1, intersection, secondUnique];
}

async function loadUavTrajectoryData(uavConfig) {
  // 如果是数组，递归处理每个配置
  if (Array.isArray(uavConfig)) {
    const results = [];
    for (const config of uavConfig) {
      const result = await loadUavTrajectoryData(config);
      results.push(result);
    }
    return results;
  }

  // 处理单个配置对象
  try {
    const [actualData, planData] = await Promise.all([
      fetch(`/json1/${uavConfig.file}`).then((res) => res.json()),
      fetch(`/json1/${uavConfig.planFile}`).then((res) => res.json()),
    ]);

    // 存储数据
    uavData.value.trajectories[uavConfig.file] = actualData;
    uavData.value.planTrajectories[uavConfig.planFile] = planData;
    uavData.value.indices[uavConfig.file] = 0;
    uavData.value.lastPositions[uavConfig.file] = actualData[0] || [];

    return { actualData, planData };
  } catch (error) {
    console.error(`加载无人机 ${uavConfig.name} 轨迹数据失败:`, error);
    return { actualData: [], planData: [] };
  }
}

function loadPoint(Viewer, pointArray) {
  pointArray.forEach((point) => {
    Viewer.entities.add({
      position: Cesium.Cartesian3.fromDegrees(point[0], point[1], point[2]),
      point: {
        color: Cesium.Color.YELLOW,
        pixelSize: 10,
      },
    });
  });
}

defineExpose({
  init,
});
</script>

<style scoped></style>
